/**
 * 
 */
package com.company.pedidos.service.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.hibernate.service.spi.ServiceException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

import com.company.base.exception.DomainException;
import com.company.canonical.beans.JsonJTableClienteBean;
import com.company.canonical.beans.JsonJTableCorreoBean;
import com.company.canonical.beans.JsonJTableDetallePedidoBean;
import com.company.canonical.beans.JsonJTableDetallePrecioBean;
import com.company.canonical.beans.JsonJTableDocumentoBean;
import com.company.canonical.beans.JsonJTableNotaBean;
import com.company.canonical.beans.JsonJTableOptionBean;
import com.company.canonical.beans.JsonJTablePedidoBean;
import com.company.canonical.beans.JsonJTablePrecioBean;
import com.company.canonical.beans.JsonJTableProductoBean;
import com.company.canonical.beans.JsonJTableTelefonoBean;
import com.company.canonical.beans.JsonJTableVendedorBean;
import com.company.pedidos.domain.Cliente;
import com.company.pedidos.domain.Correo;
import com.company.pedidos.domain.Detallelistaprecio;
import com.company.pedidos.domain.Detallepedido;
import com.company.pedidos.domain.Documentoxcobrar;
import com.company.pedidos.domain.Listaprecio;
import com.company.pedidos.domain.Nota;
import com.company.pedidos.domain.Pedido;
import com.company.pedidos.domain.Producto;
import com.company.pedidos.domain.Telefono;
import com.company.pedidos.domain.Usuario;
import com.company.pedidos.domain.Vendedor;
import com.company.pedidos.domain.Visita;
import com.company.pedidos.repository.ClienteRepository;
import com.company.pedidos.repository.CorreoRepository;
import com.company.pedidos.repository.DetallelistaprecioRepository;
import com.company.pedidos.repository.DetallepedidoRepository;
import com.company.pedidos.repository.DocumentoxcobrarRepository;
import com.company.pedidos.repository.ListaprecioRepository;
import com.company.pedidos.repository.NotaRepository;
import com.company.pedidos.repository.PedidoRepository;
import com.company.pedidos.repository.ProductoRepository;
import com.company.pedidos.repository.TelefonoRepository;
import com.company.pedidos.repository.UsuarioRepository;
import com.company.pedidos.repository.VendedorRepository;
import com.company.pedidos.repository.VisitaRepository;
import com.company.pedidos.service.PedidosService;
import com.company.util.TomadorPedidoFormat;

/**
 * @author
 * 
 */
@Repository
@Service
public class PedidosServiceImpl implements PedidosService {

	@Autowired
	private VisitaRepository visitaRepository;
	@Autowired
	private ClienteRepository clienteRepository;
	@Autowired
	private TelefonoRepository telefonoRepository;
	@Autowired
	private CorreoRepository correoRepository;
	@Autowired
	private DocumentoxcobrarRepository documentoxcobrarRepository;
	@Autowired
	private NotaRepository notaRepository;
	@Autowired
	private ProductoRepository productoRepository;
	@Autowired
	private DetallelistaprecioRepository detallelistaprecioRepository;
	@Autowired
	private UsuarioRepository usuarioRepository;
	@Autowired
	private PedidoRepository pedidoRepository;
	@Autowired
	private DetallepedidoRepository detallepedidoRepository;
	@Autowired
	private ListaprecioRepository listaprecioRepository;
	@Autowired
	private VendedorRepository vendedorRepository;

	private static final Logger logger = LoggerFactory
			.getLogger(PedidosServiceImpl.class);

	/**
	 * 
	 */
	public PedidosServiceImpl() {
	}

	public List<Visita> obtenerVisitaCliente(int idCliente)
			throws ServiceException {
		return visitaRepository.findByClienteId(idCliente);
	}

	@Override
	public List<JsonJTableOptionBean> listarTipoDocumento()
			throws ServiceException {
		List<JsonJTableOptionBean> tipoDocumentoIdentidad = new ArrayList<JsonJTableOptionBean>();
		tipoDocumentoIdentidad.add(new JsonJTableOptionBean("DNI", "1"));
		tipoDocumentoIdentidad.add(new JsonJTableOptionBean("CARNET EXTRANJERIA", "2"));
		return tipoDocumentoIdentidad;
	}

	@Override
	public List<JsonJTableOptionBean> listarEstadoPedido()
			throws ServiceException {
		List<JsonJTableOptionBean> listaEstadoPedido = new ArrayList<JsonJTableOptionBean>();

		listaEstadoPedido.add(new JsonJTableOptionBean("PENDIENTE", "1"));
		listaEstadoPedido.add(new JsonJTableOptionBean("CONFIRMADO", "2"));
		listaEstadoPedido.add(new JsonJTableOptionBean("ANULADO", "3"));
		listaEstadoPedido.add(new JsonJTableOptionBean("APROBADO", "4"));
		listaEstadoPedido.add(new JsonJTableOptionBean("ATENDIDO", "5"));
		return listaEstadoPedido;
	}

	@Override
	public Long buscarClienteCount(String tipoDocumento, String nroDocumento,
			String nombreCliente) throws ServiceException {

		Map<String, Object> attr = new HashMap<String, Object>();
		attr.put("tipoDocumento", tipoDocumento);
		attr.put("nroDocumento", nroDocumento);
		attr.put("nombreCliente", nombreCliente);
		Map<String, Object> mapQueryString = pedidoRepository
				.createQueryString("Cliente", "count", attr);
		String queryString = (String) mapQueryString.get("queryString");
		Object[] params = (Object[]) mapQueryString.get("params");

		Long count = clienteRepository.executeCountQuery(queryString, params);

		return count;

	}

	@Override
	public List<JsonJTableClienteBean> buscarCliente(String tipoDocumento,
			String nroDocumento, String nombreCliente, int jtStartIndex,
			int jtPageSize) throws ServiceException {

		Map<String, Object> attr = new HashMap<String, Object>();
		attr.put("tipoDocumento", tipoDocumento);
		attr.put("nroDocumento", nroDocumento);
		attr.put("nombreCliente", nombreCliente);
		Map<String, Object> mapQueryString = pedidoRepository
				.createQueryString("Cliente", null, attr);
		String queryString = (String) mapQueryString.get("queryString");
		Object[] params = (Object[]) mapQueryString.get("params");

		List<Cliente> clienteList = clienteRepository.executeQuery(queryString,
				jtStartIndex, jtPageSize, params);

		List<JsonJTableClienteBean> listaCliente = new ArrayList<JsonJTableClienteBean>();

		for (Cliente cliente : clienteList) {
			JsonJTableClienteBean bean = new JsonJTableClienteBean();
			bean.setId(Integer.parseInt(cliente.getId().toString()));
			bean.setCodigo(cliente.getCodigo());
			bean.setRazonSocial(cliente.getRazonSocial());
			bean.setDocumentoIdentidad(cliente.getNroDocumento());
			bean.setDireccion(cliente.getDireccion());
			bean.setRepresentante(cliente.getRepresentante());
			bean.setFechaActualizacion(TomadorPedidoFormat.toDateFormatString(cliente.getFechaCreacion()));
			bean.setUserCodigo(cliente.getUserCodigo());
			listaCliente.add(bean);
		}

		logger.debug("lista cliente: " + listaCliente.size());
		return listaCliente;
	}

	@Override
	public int obtenerNumeroCliente() throws DomainException {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public Cliente obtenerDetalleCliente(String idCliente) throws DomainException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public List<JsonJTableTelefonoBean> listarTelefonoCliente(String clienteId)
			throws DomainException {
		List<JsonJTableTelefonoBean> listaTelefono = new ArrayList<JsonJTableTelefonoBean>();
		JsonJTableTelefonoBean telefonoBean = null;
		List<Telefono> telefonoList = telefonoRepository
				.findByClienteCodigo(clienteId);
		try {

			for (Telefono telefono : telefonoList) {
				telefonoBean = new JsonJTableTelefonoBean();
				telefonoBean.setId(telefono.getId());
				telefonoBean.setTipoTelefono(telefono.getTipoTelefono());
				telefonoBean.setFechaCreacion(telefono.getFechaCreacion());
				telefonoBean.setHoraCreacion(telefono.getHoraCreacion());
				telefonoBean.setNumero(telefono.getNumero());
				telefonoBean.setUserId(telefono.getUserCodigo());
				listaTelefono.add(telefonoBean);
			}

		} catch (Exception e) {
			new DomainException(e.getMessage());
		}
		logger.debug("lista cliente: " + listaTelefono.size());
		return listaTelefono;
	}

	@Override
	public List<JsonJTableCorreoBean> listaCorreoCliente(String clienteId)
			throws ServiceException {
		List<JsonJTableCorreoBean> listaCorreo = new ArrayList<JsonJTableCorreoBean>();
		JsonJTableCorreoBean correoBean = null;
		List<Correo> correoList = correoRepository.findByClienteCodigo(clienteId);
		try {

			for (Correo correo : correoList) {

				correoBean = new JsonJTableCorreoBean();
				correoBean.setId(correo.getId());
				correoBean.setFechaCreacion(correo.getFechaCreacion());
				correoBean.setHoraCreacion(correo.getHoraCreacion());
				correoBean.setMail(correo.getMail());
				correoBean.setTipoMail(correo.getTipoMail());
				correoBean.setUserId(correo.getUserCodigo());
				listaCorreo.add(correoBean);
			}

		} catch (Exception e) {
			new DomainException(e.getMessage());
		}
		logger.debug("lista cliente: " + listaCorreo.size());
		return listaCorreo;
	}

	@Override
	public Long listaDocumentoCobrarClienteCount(String clienteId)
			throws ServiceException {

		Map<String, Object> attr = new HashMap<String, Object>();
		attr.put("clienteId", clienteId);
		Map<String, Object> mapQueryString = pedidoRepository
				.createQueryString("Documentoxcobrar", "count", attr);
		String queryString = (String) mapQueryString.get("queryString");
		Object[] params = (Object[]) mapQueryString.get("params");

		Long count = documentoxcobrarRepository.executeCountQuery(queryString,
				params);

		return count;

	}

	@Override
	public List<JsonJTableDocumentoBean> listaDocumentoCobrarCliente(
			String clienteId, int jtStartIndex, int jtPageSize)
			throws ServiceException {

		Map<String, Object> attr = new HashMap<String, Object>();
		attr.put("clienteId", clienteId);
		Map<String, Object> mapQueryString = pedidoRepository
				.createQueryString("Documentoxcobrar", null, attr);
		String queryString = (String) mapQueryString.get("queryString");
		Object[] params = (Object[]) mapQueryString.get("params");

		List<Documentoxcobrar> documentoxcobrarList = documentoxcobrarRepository
				.executeQuery(queryString, jtStartIndex, jtPageSize, params);

		List<JsonJTableDocumentoBean> listaDocumento = new ArrayList<JsonJTableDocumentoBean>();
		JsonJTableDocumentoBean documentoBean = null;

		try {

			for (Documentoxcobrar dc : documentoxcobrarList) {

				documentoBean = new JsonJTableDocumentoBean();
				documentoBean.setId(dc.getId());
				documentoBean.setFechaCreacion(dc.getFechaCreacion());
				documentoBean.setHoraCreacion(dc.getHoraCreacion());
//				documentoBean.setEstado("PENDIENTE");
				documentoBean.setDiasCredito(dc.getDiasCredito());
				documentoBean.setMoneda(dc.getMoneda());
				documentoBean.setSaldo(dc.getSaldo());
				documentoBean.setTipoDocumento(dc.getTipoDocumento());
				documentoBean.setNroDocumento(dc.getNroDocumento());
				documentoBean.setFechaVencimiento(dc.getFechaVencimiento());
				documentoBean.setUserId(dc.getUserCodigo());
				listaDocumento.add(documentoBean);
			}

		} catch (Exception e) {
			new DomainException(e.getMessage());
		}
		logger.debug("lista cliente: " + listaDocumento.size());
		return listaDocumento;
	}

	@Override
	public Long listaNotaClienteCount(String clienteId) throws ServiceException {

		Map<String, Object> attr = new HashMap<String, Object>();
		attr.put("clienteId", clienteId);
		Map<String, Object> mapQueryString = pedidoRepository
				.createQueryString("Nota", "count", attr);
		String queryString = (String) mapQueryString.get("queryString");
		Object[] params = (Object[]) mapQueryString.get("params");

		Long count = notaRepository.executeCountQuery(queryString, params);

		return count;
	}

	@Override
	public List<JsonJTableNotaBean> listaNotaCliente(String clienteId,
			int jtStartIndex, int jtPageSize) throws ServiceException {

		Map<String, Object> attr = new HashMap<String, Object>();
		attr.put("clienteId", clienteId);
		Map<String, Object> mapQueryString = pedidoRepository
				.createQueryString("Nota", null, attr);
		String queryString = (String) mapQueryString.get("queryString");
		Object[] params = (Object[]) mapQueryString.get("params");

		List<Nota> notaList = notaRepository.executeQuery(queryString,
				jtStartIndex, jtPageSize, params);

		List<JsonJTableNotaBean> listaNota = new ArrayList<JsonJTableNotaBean>();
		JsonJTableNotaBean notaBean = new JsonJTableNotaBean();
		try {

			for (Nota nota : notaList) {
				notaBean = new JsonJTableNotaBean();
				notaBean.setId(nota.getId());
				notaBean.setFechaCreacion(nota.getFechaCreacion());
				notaBean.setHoraCreacion(nota.getHoraCreacion());
				notaBean.setNota(nota.getComentario());
				notaBean.setUserId(nota.getUserCodigo());
				listaNota.add(notaBean);
			}

		} catch (Exception e) {
			new DomainException(e.getMessage());
		}
		logger.debug("lista cliente: " + listaNota.size());
		return listaNota;
	}

	@Override
	public Long buscarProductoCount(String codigoProducto,
			String categoriaProducto) throws ServiceException {

		Map<String, Object> attr = new HashMap<String, Object>();
		attr.put("descripcion", codigoProducto);
		attr.put("categoriaCodigo", categoriaProducto);
		Map<String, String> oper = new HashMap<String, String>();
		oper.put("descripcion", "like");
		oper.put("categoriaCodigo", "like");
		Map<String, Object> mapQueryString = pedidoRepository
				.createQueryString("Producto", "count", attr, oper);
		String queryString = (String) mapQueryString.get("queryString");
		Object[] params = (Object[]) mapQueryString.get("params");

		Long count = productoRepository.executeCountQuery(queryString, params);

		return count;

	}

	@Override
	public List<JsonJTableProductoBean> buscarProducto(String codigoProducto,
			String categoriaProducto, Integer jtStartIndex, Integer jtPageSize)
			throws ServiceException {

		Map<String, Object> attr = new HashMap<String, Object>();
		attr.put("descripcion", codigoProducto);
		attr.put("categoriaCodigo", categoriaProducto);
		Map<String, String> oper = new HashMap<String, String>();
		oper.put("descripcion", "like");
		oper.put("categoriaCodigo", "like");
		Map<String, Object> mapQueryString = pedidoRepository
				.createQueryString("Producto", null, attr, oper);
		String queryString = (String) mapQueryString.get("queryString");
		Object[] params = (Object[]) mapQueryString.get("params");

		List<Producto> productoList = productoRepository.executeQuery(
				queryString, jtStartIndex, jtPageSize, params);

		List<JsonJTableProductoBean> listaProducto = new ArrayList<JsonJTableProductoBean>();
		JsonJTableProductoBean productoBean = null;
		try {
			logger.debug("lista producto DB: " + productoList.size());
			for (Producto producto : productoList) {
				productoBean = new JsonJTableProductoBean();
				productoBean.setId(producto.getId());
				productoBean.setCategoria(producto.getCategoriaCodigo());
				productoBean.setCodigo(producto.getCodigo());
				productoBean.setDescripcion(producto.getDescripcion());
				productoBean.setUnidadMedida(producto.getUnidadMedidaCodigo());
				productoBean.setStock(producto.getStock().doubleValue());
				listaProducto.add(productoBean);
			}

		} catch (Exception e) {
			new DomainException(e.getMessage());
		}
		logger.debug("lista producto: " + listaProducto.size());
		return listaProducto;
	}

	@Override
	public Long buscarPrecioCount(String codigoListaPrecio, String fechaVigencia)
			throws ServiceException {
		Map<String, Object> attr = new HashMap<String, Object>();
		attr.put("codigo", codigoListaPrecio);
		attr.put("fechaFin",
				TomadorPedidoFormat.toIntegerFormatDate(fechaVigencia));
		Map<String, Object> mapQueryString = pedidoRepository
				.createQueryString("Listaprecio", "count", attr);
		String queryString = (String) mapQueryString.get("queryString");
		Object[] params = (Object[]) mapQueryString.get("params");
		Long count = listaprecioRepository.executeCountQuery(queryString,
				params);
		return count;

	}

	@Override
	public List<JsonJTablePrecioBean> buscarPrecio(String codigoListaPrecio,
			String fechaVigencia, int jtStartIndex, int jtPageSize)
			throws ServiceException {

		Map<String, Object> attr = new HashMap<String, Object>();
		attr.put("codigo", codigoListaPrecio);
		attr.put("fechaFin",
				TomadorPedidoFormat.toIntegerFormatDate(fechaVigencia));
		Map<String, Object> mapQueryString = pedidoRepository
				.createQueryString("Listaprecio", null, attr);
		String queryString = (String) mapQueryString.get("queryString");
		Object[] params = (Object[]) mapQueryString.get("params");
		List<Listaprecio> listaprecioList = listaprecioRepository.executeQuery(
				queryString, jtStartIndex, jtPageSize, params);

		List<JsonJTablePrecioBean> listaPrecio = new ArrayList<JsonJTablePrecioBean>();
		JsonJTablePrecioBean precioBean = null;

		try {

			for (Listaprecio lp : listaprecioList) {
				precioBean = new JsonJTablePrecioBean();
				precioBean.setId(Integer.parseInt(lp.getId().toString()));
				precioBean.setCodigo(lp.getCodigo());
				precioBean.setDescripcion(lp.getDescripcion());
				precioBean.setFechaVigencia(TomadorPedidoFormat
						.toDateFormatString(lp.getFechaFin()));
				listaPrecio.add(precioBean);
			}

		} catch (Exception e) {
			new DomainException(e.getMessage());
		}
		logger.debug("lista precio: " + listaPrecio.size());
		return listaPrecio;
	}

	@Override
	public List<JsonJTableDetallePrecioBean> listaDetallePrecio(
			int listaPrecioId) throws ServiceException {

		List<JsonJTableDetallePrecioBean> listaDetallePrecio = new ArrayList<JsonJTableDetallePrecioBean>();
		JsonJTableDetallePrecioBean detallePrecioBean = null;
		List<Detallelistaprecio> detallelistaprecioList = detallelistaprecioRepository
				.findByListaPrecioId(listaPrecioId);
		try {

			for (Detallelistaprecio dlp : detallelistaprecioList) {
				detallePrecioBean = new JsonJTableDetallePrecioBean();
				detallePrecioBean.setId(dlp.getId().intValue());
				detallePrecioBean.setCodigoProducto(dlp.getProductoCodigo());
				detallePrecioBean.setMoneda(dlp.getMoneda());
				detallePrecioBean.setPrecio(dlp.getPrecio().intValue());
				listaDetallePrecio.add(detallePrecioBean);
			}

		} catch (Exception e) {
			new DomainException(e.getMessage());
		}
		logger.debug("lista detallePrecio: " + listaDetallePrecio.size());
		return listaDetallePrecio;
	}

	@Override
	public Usuario autorizarUsuario(String usuario, String password) {
		List<Usuario> usuarioList = usuarioRepository.findByUsuarioAndPassword(
				usuario, password);
		Usuario user = null;
		if (!usuarioList.isEmpty()) {
			user = usuarioList.get(0);
		}
		return user;
	}

	@Override
	public Long buscarPedidoCount(String fechaPedido, String clienteCodigo,
			String estado) throws DomainException {
		Map<String, Object> attr = new HashMap<String, Object>();
		attr.put("fechaPedido",
				TomadorPedidoFormat.toIntegerFormatDate(fechaPedido));
		attr.put("clienteCodigo", clienteCodigo);
		attr.put("estado", TomadorPedidoFormat.toIntegerFormat(estado));
		Map<String, Object> mapQueryString = pedidoRepository
				.createQueryString("Pedido", "count", attr);
		String queryString = (String) mapQueryString.get("queryString");
		Object[] params = (Object[]) mapQueryString.get("params");

		Long count = pedidoRepository.executeCountQuery(queryString, params);

		return count;
	}

	@Override
	public List<JsonJTablePedidoBean> buscarPedido(String fechaPedido,
			String clienteCodigo, String estado, int jtStartIndex,
			int jtPageSize) throws DomainException {

		Map<String, Object> attr = new HashMap<String, Object>();
		attr.put("fechaPedido",
				TomadorPedidoFormat.toIntegerFormatDate(fechaPedido));
		attr.put("clienteCodigo", clienteCodigo);
		attr.put("estado", TomadorPedidoFormat.toIntegerFormat(estado));
		Map<String, Object> mapQueryString = pedidoRepository
				.createQueryString("Pedido", null, attr);
		String queryString = (String) mapQueryString.get("queryString");
		Object[] params = (Object[]) mapQueryString.get("params");

		List<Pedido> pedidoList = pedidoRepository.executeQuery(queryString,
				jtStartIndex, jtPageSize, params);
		List<JsonJTablePedidoBean> beans = new ArrayList<JsonJTablePedidoBean>();
		JsonJTablePedidoBean bean = null;
		for (Pedido pedido : pedidoList) {
			bean = new JsonJTablePedidoBean();
			bean.setCodigoCliente(pedido.getClienteCodigo());
			bean.setEstado(pedido.getEstado());
			bean.setHoraPedido(pedido.getHoraPedido());
			bean.setVendedorId(pedido.getVendedorId());
			bean.setFechaPedido(TomadorPedidoFormat.toDateFormatString(pedido.getFechaPedido()));
			bean.setId(Integer.parseInt(pedido.getId().toString()));
			bean.setIgv(pedido.getIgv().doubleValue());
			bean.setNroPedido(pedido.getNroPedido());
			bean.setSubTotal(pedido.getSubTotal().doubleValue());
			bean.setTipoCambio(pedido.getTipoCambio().doubleValue());
			bean.setTipoMoneda(pedido.getTipoMoneda());
			bean.setTotal(pedido.getTotal().doubleValue());
			bean.setTotalDescuento(pedido.getTotalDescuento().doubleValue());
			beans.add(bean);
		}

		return beans;
	}

	@Override
	public List<JsonJTableDetallePedidoBean> listaDetallePedido(int pedidoId)
			throws DomainException {
		// TODO Auto-generated method stub

		List<Detallepedido> detallepedidoList = detallepedidoRepository
				.findByPedidoId(pedidoId);
		List<JsonJTableDetallePedidoBean> detallePedidoBeans = new ArrayList<JsonJTableDetallePedidoBean>();
		JsonJTableDetallePedidoBean bean = null;
		for (Detallepedido dp : detallepedidoList) {
			bean = new JsonJTableDetallePedidoBean();
			bean.setDescuento(dp.getDescuento().doubleValue());
			bean.setId(Integer.parseInt(dp.getId().toString()));
			bean.setPrecioCosto(dp.getPrecioCosto().doubleValue());
			bean.setProductoCodigo(dp.getProductoCodigo());
			bean.setPrecioVenta(dp.getPrecioVenta().doubleValue());
			detallePedidoBeans.add(bean);
		}

		return detallePedidoBeans;
	}

	@Override
	public Long buscarVendedorCount(String nombres, String apellidoPaterno,
			String apellidoMaterno) throws DomainException {
		Map<String, Object> attr = new HashMap<String, Object>();
		attr.put("nombres", nombres);
		attr.put("paterno", apellidoPaterno);
		attr.put("materno", apellidoMaterno);
		Map<String, Object> mapQueryString = pedidoRepository
				.createQueryString("Vendedor", "count", attr);
		String queryString = (String) mapQueryString.get("queryString");
		Object[] params = (Object[]) mapQueryString.get("params");

		Long count = vendedorRepository.executeCountQuery(queryString, params);

		return count;
	}

	@Override
	public List<JsonJTableVendedorBean> buscarVendedor(String nombres,
			String apellidoPaterno, String apellidoMaterno, int jtStartIndex,
			int jtPageSize) throws DomainException {

		Map<String, Object> attr = new HashMap<String, Object>();
		attr.put("nombres", nombres);
		attr.put("paterno", apellidoPaterno);
		attr.put("materno", apellidoMaterno);
		Map<String, Object> mapQueryString = pedidoRepository
				.createQueryString("Vendedor", null, attr);
		String queryString = (String) mapQueryString.get("queryString");
		Object[] params = (Object[]) mapQueryString.get("params");

		List<Vendedor> vendedorList = vendedorRepository.executeQuery(
				queryString, jtStartIndex, jtPageSize, params);
		JsonJTableVendedorBean bean = null;
		List<JsonJTableVendedorBean> beans = new ArrayList<JsonJTableVendedorBean>();
		for (Vendedor v : vendedorList) {
			bean = new JsonJTableVendedorBean();
			bean.setCodigo(v.getCodigo());
			bean.setNombre(v.getNombres());
			bean.setDireccion(v.getDireccion());
			bean.setId(Integer.parseInt(v.getId().toString()));
			bean.setApellidos(v.getPaterno().trim() + " "
					+ v.getMaterno().trim());
			beans.add(bean);
		}

		return beans;
	}
}
